import { validEmpty, bankCardValidate } from "./plugFun"
// 邮政编码
function validPostcode(rule, value, callback) {
    if (value == "") {
        callback(new Error(rule.message))
    } else {
        let pattern = /^[0-9]{6}$/;
        let flag = pattern.test(value);
        if (!flag) {
            callback(new Error('请输入正确的邮政编码'))
        } else {
            callback()
        }
    }
}
// 手机号
function validPhone(rule, value, callback) {
    if (value == "") {
        callback(new Error(rule.message))
    } else {
        const reg = /^(\+86|0086)?\s*1[345789]\d{9}$/
        let flag = reg.test(value);
        if (!flag) {
            callback(new Error('请输入正确的手机号码'))
        } else {
            callback()
        }
    }
}
// 邮箱
function validMail(rule, value, callback) {
    let reg = new RegExp("^[a-z0-9]+([._\\-]*[a-z0-9])*@([a-z0-9]+[-a-z0-9]*[a-z0-9]+.){1,63}[a-z0-9]+$"); //正则表达式
    if (!value) {
        callback(new Error(rule.message))
    } else if (!reg.test(value)) {
        callback(new Error('请输入正确的邮箱'))
    } else {
        callback()
    }
}
// 座机电话
function validTelePhone(rule, value, callback) {
    const reg = /0\d{2,3}-\d{7,8}/
    if (!rule.required && value === "" || !rule.required && value === null) {
        callback()
    } else if (!reg.test(value)) {
        callback(new Error('请输入正确的座机号码'))
    } else {
        callback()
    }
}
// 0.00
function validAmount(rule, value, callback) {
    const reg = /(^[1-9]\d{0,3}$)|(^\.\d{1,2}$)|(^[1-9]\d{0,3}\.\d{1,2}$)/
    if (!reg.test(value)) {
        callback(new Error('最多保留两位有效数字'))
    } else {
        callback()
    }
}
// 是否为数组
function validArray(rule, value, callback) {
    if (!Array.isArray(value)) {
        callback(new Error(rule.message))
    } else if (value.length === 0) {
        callback(new Error(rule.message))
    } else {
        callback()
    }
}
// 密码必须字母+数字组合（6-20位）
function validPassword(rule, value, callback) {
    const reg = /^(?![0-9]+$)(?![a-zA-Z]+$)[0-9A-Za-z]{6,20}$/
    if (!reg.test(value)) {
        callback(new Error('密码必须字母+数字组合（6-20位）'))
    } else {
        callback()
    }
}
function validPhoneString(rule, value, callback) {
    if (value) {
        const reg = /^(13[0-9]|14[01456879]|15[0-35-9]|16[2567]|17[0-8]|18[0-9]|19[0-35-9])\d{8}$/
        const arr = value.split(",");
        for (let i = 0; i < arr.length; i++) {
            if (!reg.test(value)) {
                callback(new Error('格式不正确'))
                return false
            }
        }
        callback()
    } else {
        callback(new Error(rule.message))
    }
}
// 身份证
function validateIdCard(rule, value, callback) {
    let regIdCard = /^(^[1-9]\d{7}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])\d{3}$)|(^[1-9]\d{5}[1-9]\d{3}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])((\d{4})|\d{3}[Xx])$)$/;
    if (!value) {
        callback(new Error(rule.message))
    }
    if (regIdCard.test(value)) {
        if (value.length == 18) {
            let idCardWi = new Array(7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2);//将前17位加权因子保存在数组里
            let idCardY = new Array(1, 0, 10, 9, 8, 7, 6, 5, 4, 3, 2);//这是除以11后，可能产生的11位余数、验证码，也保存成数组
            let idCardWiSum = 0;//用来保存前17位各自乖以加权因子后的总和
            for (let i = 0; i < 17; i++) {
                idCardWiSum += value.substring(i, i + 1) * idCardWi[i];
            }
            let idCardMod = idCardWiSum % 11;//计算出校验码所在数组的位置
            let idCardLast = value.substring(17);//得到最后一位身份证号码
            //如果等于2，则说明校验码是10，身份证号码最后一位应该是X
            if (idCardMod == 2) {
                if (idCardLast == "X" || idCardLast == "x") {
                    callback()
                } else {
                    callback(new Error('请输入正确的身份证号'))
                }
            } else {
                //用计算出的验证码与最后一位身份证号码匹配，如果一致，说明通过，否则是无效的身份证号码
                if (idCardLast == idCardY[idCardMod]) {
                    callback()
                } else {
                    callback(new Error('请输入正确的身份证号'))
                }
            }
        } else {
            callback(new Error('请输入正确的身份证号'))
        }
    } else {
        callback(new Error('请输入正确的身份证号'))
    }
}
// 是否为数字
function validNum(rule, value, callback) {
    isNaN(Number(value)) ? callback(new Error(rule.message)) : callback()
}

function validPositive(rule, value, callback) {
    value < 0 ? callback(new Error(rule.message)) : callback()
}
// 整数
function validInteger(rule, value, callback) {
    const reg = /^[0-9]\d*$/
    reg.test(value) ? callback() : callback(new Error(rule.message))
}
// 价格
function validPrice(rule, value, callback) {
    const reg = /(^[1-9]([0-9]+)?(\.[0-9]{1,2})?$)|(^[0-9]\.[0-9]([0-9])?$)/;
    reg.test(value) ? callback() : callback(new Error(rule.message))
}
// 是否名称重复
function validDuplic(rule, value, callback) {
    if (!Array.isArray(rule.duplicData)) {
        throw new Error('duplicData is not Array Type!')
    }
    rule.duplicData.includes(value) ? callback(new Error(rule.message)) : callback()
}

function validCompare(rule, value, callback) {
    if (typeof rule.handler !== 'function') {
        throw new Error('handler is not a Function!')
    }
    rule.handler(value) ? callback() : callback(new Error(rule.message))
}
// 最大长度
function validMaxlength(rule, value, callback) {
    String(value).length > rule.maxlength ? callback(new Error(rule.message)) : callback()
}
// 最小长度
function validMinlength(rule, value, callback) {
    if (!rule.required && validEmpty(value)) {
        callback()
        return
    }
    String(value).length < rule.minlength ? callback(new Error(rule.message)) : callback()
}
// 最大值
function validMax(rule, value, callback) {
    parseFloat(value) > parseFloat(rule.max) ? callback(new Error(rule.message)) : callback()
}
// 最小值
function validMin(rule, value, callback) {
    parseFloat(value) < parseFloat(rule.min) ? callback(new Error(rule.message)) : callback()
}
// 中文
function validChinese(rule, value, callback) {
    const reg = /^[\u4E00-\u9FA5]{1,5}$/;
    if (!value) {
        callback(new Error(rule.message))
    } else if (!reg.test(value)) {
        callback(new Error('请输入中文'))
    } else {
        callback()
    }
}
// 数字和字母
function validAccount(rule, value, callback) {
    const reg = /^[A-Za-z0-9]{6,20}$/;
    if (!value) {
        callback(new Error(rule.message))
    } else if (!reg.test(value)) {
        callback(new Error('请输入字母或数字组合6-20位组合'))
    } else {
        callback()
    }
}
// 银行卡验证
function validBank(rule, value, callback) {
    if (!value) {
        callback(new Error(rule.message))
    } else if (!bankCardValidate(value)) {
        callback(new Error('请输入正确的银行卡号'))
    } else {
        callback()
    }
}
// 不验证都通过
function validNoRequire(rule, val, callback) {
    callback()
}


export function getDefaultRule(type) {
    const map = {
        required: {},
        array: {
            validator: validArray
        },
        number: {
            validator: validNum
        },
        phone: {
            validator: validPhone
        },
        mail: {
            validator: validMail
        },
        idCard: {
            validator: validateIdCard
        },
        integer: {
            validator: validInteger
        },
        price: {
            validator: validPrice
        },
        duplic: {
            validator: validDuplic
        },
        positive: {
            validator: validPositive
        },
        compare: {
            validator: validCompare
        },
        maxlength: {
            validator: validMaxlength
        },
        minlength: {
            validator: validMinlength
        },
        max: {
            validator: validMax
        },
        min: {
            validator: validMin
        },
        postcode: {
            validator: validPostcode
        },
        telePhone: {
            validator: validTelePhone
        },
        Chinese: {
            validator: validChinese
        },
        account: {
            validator: validAccount
        },
        'no-required': {
            validator: validNoRequire
        },
        Amount: {
            validator: validAmount
        },
        password: {
            validator: validPassword
        },
        phoneString: {
            validator: validPhoneString
        },
        bank: {
            validator: validBank
        },

    }
    return map[type]
}